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

import java.lang.reflect.Constructor;

import java.util.ArrayList;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Set;

import javax.swing.ImageIcon;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.andami.PluginServices;

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

import org.gvsig.app.project.Project;

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

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.extensionpoint.ExtensionBuilder;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

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

/**

 * Factory of ProjectDocument.

 *

 * @author 2005-         Vicente Caballero

 * @author 2009-         Joaquin del Cerro

 * 

 */

public abstract class AbstractDocumentManager implements DocumentManager {

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

    /**

     * Returns the type of document priority.

     *

     * This priority is used when order document factories in UI.

     * 

     * @return Priority.

     */

    public int getPriority() {

        return 10;

    }

    /**

     * Returns the icon for the type of document.

     *

     * @return Image.

     */

    public ImageIcon getIcon() {

        return PluginServices.getIconTheme().get("document-icon-sel");

    }

    /**

     * Returns the icon for the type of document when is selected

     *

     * @return Image.

     */

    public ImageIcon getIconSelected() {

        return PluginServices.getIconTheme().get("document-icon");

    }

    /**

     * Returns the title of type of document.

     *

     * @return String title for type of document

     */

    public String getTitle() {

        return PluginServices.getText(this, "documento");

    }

    public AbstractDocument createDocumentByUser() {

        return createDocument();

    }

    public Iterator<? extends Document> createDocumentsByUser() {

        Set<AbstractDocument> doc = new HashSet<AbstractDocument>(1);

        doc.add(createDocumentByUser());

        return doc.iterator();

    }

    /**

     * @see ExtensionBuilder

     */

    public Object create() {

        return this;

    }

    /**

     * @see ExtensionBuilder

     */

    public Object create(Object[] args) {

        return this;

    }

    /**

     * @see ExtensionBuilder

     */

    @SuppressWarnings("rawtypes")

    public Object create(Map args) {

        return this;

    }

    public IWindow getMainWindow(Document doc) {

        return getMainWindow(doc, null);

    }

    /**

     * Return true if the name exists to another document.

     *

     * @param project

     * @param documentName

     *

     * @return True if the name exists.

     * @deprecated use instead  project.getProjectDocument

     */

    public boolean existName(Project project, String documentName) {

        return project.getDocument(documentName, getTypeName())!=null;

    }

    /**

     * Return the class or interface for the documents managed by this factory.

     * @return The document class;

     */

    @SuppressWarnings("rawtypes")

    abstract protected Class getDocumentClass();

    public Object createFromState(PersistentState state) throws PersistenceException {

        Document doc = this.createDocument();

        return doc;

    }

    public void loadFromState(PersistentState state, Object object) throws PersistenceException {

        Document doc = (Document) object;

        doc.loadFromState(state);

    }

    public void saveToState(PersistentState state, Object obj) throws PersistenceException {

        Document doc = (Document) obj;

        doc.saveToState(state);

    }

    @SuppressWarnings({ "rawtypes", "unchecked" })

    public boolean manages(Class theClass) {

        return this.getDocumentClass().isAssignableFrom(theClass);

    }

    @SuppressWarnings("rawtypes")

    public boolean manages(PersistentState state) {

        try {

            Class theClass;

            theClass = (Class) Class.forName(state.getTheClassName());

            return manages(theClass);

        } catch (ClassNotFoundException e) {

            return false;

        }

    }

    public List<DynStruct> getDefinitions() {

        DynStruct definition = this.getDefinition(this.getDocumentClass().getName());

        List<DynStruct> definitions = new ArrayList<DynStruct>();

        definitions.add(definition);

        return definitions;

    }

    public String getDomainName() {

        return PersistenceManager.DEFAULT_DOMAIN_NAME;

    }

    public String getDomainURL() {

        return PersistenceManager.DEFAULT_DOMAIN_URL;

    }

    @SuppressWarnings({ "unchecked", "rawtypes" })

    public List getManagedClasses() {

        List classes = new ArrayList();

        classes.add(this.getDocumentClass());

        return classes;

    }

    @SuppressWarnings("rawtypes")

    public Class getManagedClass(Object object) {

        return this.getDocumentClass();

    }

    @SuppressWarnings("rawtypes")

    public Class getManagedClass(PersistentState state) {

        return this.getDocumentClass();

    }

    @SuppressWarnings("rawtypes")

    public Class getManagedClass(String name) {

        return this.getDocumentClass();

    }

    @SuppressWarnings("rawtypes")

    public String getManagedClassName(Object object) {

        Class clazz = this.getManagedClass(object);

        if (clazz != null){

            return clazz.getName();

        }

        return null;

    }

    @SuppressWarnings("rawtypes")

    protected IDocumentWindow createDocumentWindow(Document document) {

        IDocumentWindow documentWindow = null;

        Class windowClass = getMainWindowClass();

        try {

            try {

                Constructor constructor;

                constructor =

                    windowClass.getConstructor(new Class[] { Document.class });

                documentWindow =

                    (IDocumentWindow) constructor

                        .newInstance(new Object[] { document });

            } catch (NoSuchMethodException e1) {

                documentWindow = (IDocumentWindow) windowClass.newInstance();

                documentWindow.setDocument(document);

            }

        } catch (Exception e) {

            logger.warn("Can't create the document window.", e);

            return null;

        }

        return documentWindow;

    }

}